package com.yaoxiaoqing.objectclass;

/**
 * 面向过程(POP) 与面向对象(OOP)
 * 面向对象：Object Oriented Programming
 * 面向过程：Procedure Oriented Programming
 * -------------------------------------------------------------------
 * 一、学习面向对象内容的三条主线
 * 1.Java 类及类的成员：属性、方法、构造器、代码块、内部类
 * 2.面向对象的三大特征：封装、继承、多态性、(抽象性)
 * 3.其它关键字：this、super、static、final、abstract、interface、package、import 等
 * <p>
 * 二、人把大象装进冰箱
 * 1.面向过程:强调的是功能行为，以函数为最小单位，考虑怎么做。
 * <p>
 * ① 打开冰箱
 * ② 把大象装进冰箱
 * ③ 把冰箱门关住
 * <p>
 * 2.面向对象:强调具备了功能的对象，以类/对象为最小单位，考虑谁来做。
 * 人{
 * 打开(冰箱){
 * 冰箱.开门();
 * }操作(大象){
 * 大象.进入(冰箱);
 * }关闭(冰箱){
 * 冰箱.关门();
 * }
 * }
 * <p>
 * 冰箱{
 * 开门(){
 * }
 * 关门(){
 * }
 * }
 * <p>
 * 大象{
 * 进入(冰箱){
 * }
 * }
 * <p>
 * 类与对象的创建及使用----------------------------------------------------------
 * * 一、设计类、其实就是设计类的成员
 * * Field = 属性 = 成员变量 = 域、字段
 * * Method = (成员)方法 = 函数
 * *
 * * 创建类 = 类的实例化 = 实例化类
 * *
 * * 二.类和对象的使用(面向对象思想落地的实现)
 * * 1.创建类，设计类的成员
 * * 2.创建类的对象
 * * 3.通过“对象.属性”或“对象.方法”调用对象的结构
 * * 三、如果创建类一个类的多个对象，则每个对象都独立的拥有一套类的属性。(非 static 的)
 * * 	  意味着:如果我们修改一个对象的属性 a，则不影响另外一个对象属性 a 的值。
 */
public class OrientedClass {
    public static void main(String[] args) {
        //测试类
        PersonTest();
        //类的成员之一：属性
        UserTest();
        //练习1
        Practice1();
        //类中方法的声明和使用
        CustomerTest();
        //练习2
        Practice2();
        //练习3
        Practice3();

        int[] arr = {1, 2, 3, 4};//简写
    }

    public static void PersonTest() {
        //2.创建 Person 类的对象
        //创建对象的语法：类名对象名=new 类名();

        Person p1 = new Person();
        //调用类的结构：属性、方法
        //调用属性：对象.属性
        p1.name = "tom";
        p1.age = 25;
        p1.isMale = true;
        System.out.println(p1.name);

        //调用方法：对象.方法
        p1.eat();
        p1.sleep();
        p1.talk("chinese");
        //**************************
        Person p2 = new Person();
        System.out.println(p2.name);//null
        System.out.println(p2.isMale);//false  boolean类型默认值为false
        //***************************
        //将 p1 变量保存的对象地址值赋给 p3,导致 p1 和 p3 指向了堆空间中的一个对象实体。
        Person p3 = p1;
        System.out.println(p3.name);

        p3.age = 10;
        System.out.println(p1.age);

    }

    // 类中属性的使用
    public static void UserTest() {
        User u1 = new User();
        System.out.println(u1.name);//null
        System.out.println(u1.age);//0
        System.out.println(u1.isMale);//false
        u1.talk("中文");
    }

    //练习1
    public static void Practice1() {
        Student stu = new Student();
        stu.name = "小明";
        stu.age = 16;

        Teacher tea = new Teacher();
        tea.name = "王先生";
        tea.age = 27;

        tea.say(tea.name, tea.age);
        stu.say(stu.name, stu.age);
    }

    //类中方法的声明和使用
    public static void CustomerTest() {
        Customer cus = new Customer();
    }

    //练习2: 利用面向对象的编程方法，设计类Circle计算圆的面积。
    public static void Practice2() {
        Circle c = new Circle();
        c.radius = 2.1;
        double area = c.findArea();
        System.out.println("面积为" + area);
    }
    //练习3
    /*
     * 4. 对象数组题目：定义类Student，包含三个属性：
     * 学号number(int)，年级state(int)，成绩score(int)。
     * 创建20个学生对象，学号为1到20，年级和成绩都由随机数确定。
     * 问题一：打印出3年级(state值为3）的学生信息。
     * 问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息
     * 提示：  1) 生成随机数：Math.random()，返回值类型double;
     * 		2) 四舍五入取整：Math.round(double d)，返回值类型long。
     *
     */
    public static void Practice3(){
        //声明一个student类型的数组
        Student[] stu = new Student[20];
        for (int i = 0; i < stu.length; i++) {
            //给数组元素赋值
            stu[i].number = i + 1;
            //年级 [1,6]  [12,]
            stu[i].state =(int)(Math.random()*(6-1+1) + 1);
            //成绩：[0,100]
            stu[i].state = (int) Math.random() * 101;
        }
        //遍历学生数组 3年级
        for (int i = 0; i < stu.length; i++) {
            if (stu[i].state == 3) {
                System.out.println(stu[i].info());
            }
        }
//        问题二：使用冒泡排序按学生成绩排序，并遍历所有学生信息

        for (int i = 0; i < stu.length; i++) {
            for (int j = 0; j < stu.length-i-1; j++) {
                if (stu[j].score > stu[j + 1].score) {
                    //如果需要换顺序，交换的是数组的元素，Student对象
                    Student temp = stu[j];
                    stu[j]= stu[j+1];
                    stu[j+1] = temp;
                }
            }
        }
        

    }
}

/*
 * 类的语法格式：
 * 修饰符 class 类名{
 * 		属性声明;
 * 		方法声明;
 * }
 * 说明：修饰符 public：类可以被任意访问类的正文要用{  }括起来
 */
//1.创建类，设计类的成员
class Person {
    //属性：对应类中的成员变量
    String name;
    int age;
    boolean isMale;

    //方法：对应类中的成员方法
    public void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }

    public void talk(String language) {
        System.out.println("人可以说话，使用的是：" + language);
    }

}

/*
 * 类中属性的使用
 *
 * 属性(成员变量)	vs	局部变量
 * 1.相同点:
 * 		1.1 定义变量的格式:数据类型 变量名 = 变量值
 * 		1.2 先声明，后使用
 * 		1.3 变量都有其对应的作用域
 *
 * 2.不同点:
 * 		2.1 在类中声明的位置不同
 * 		属性:直接定义在类的一对{}内
 * 		局部变量:声明在方法内、方法形参、构造器形参、构造器内部的变量
 *
 * 		2.2 关于权限修饰符的不同
 * 		属性:可以在声明属性时，指明其权限，使用权限修饰符。
 * 			常用的权限修饰符:private、public、缺省、protected
 * 			目前声明属性时，都使用缺省即可。
 * 		局部变量:不可以使用权限修饰符。
 *
 * 		2.3 默认初始化值的情况:------------------------------------
 * 		属性:类的属性，根据其类型，都有默认初始化值。
 * 			整型(byte、short、int、long):0
 * 			浮点型(float、double):0.0
 * 			字符型(char):0(或‘\u0000’)
 * 			布尔型(boolean):false
 *
 * 			引用数据类型(类、数组、接口):null
 *
 * 		局部变量:没有默认初始化值-------------------------------------
 * 			意味着:在调用局部变量之前，一定要显式赋值。
 * 			特别地:形参在调用时,赋值即可。例，45 行
 *
 * 		2.4 在内存中加载的位置，亦各不相同。
 * 		属性:加载到堆空间中(非 static)
 * 		局部变量:加载到栈空间
 */
class User {
    //属性
    String name; //不加private即为缺省
    public int age;
    boolean isMale;

    public void talk(String language) {
        System.out.println("我们使用" + language + "进行交流");
    }

    public void eat() {
        String food = "石头饼";//局部变量
        System.out.println("北方人喜欢吃" + food);
    }

}

/*
编写教师类和学生类，并通过测试类创建对象进行测试
Student类
属性:
name:String age:int major:String interests:String
方法:say() 返回学生的个人信息
Teacher类
属性:
name:String age:int teachAge:int course:String
方法:say() 输出教师的个人信息
*/
class Student {
    String name;
    int age;
    String major;
    String interests;
    int number;
    int state;
    int score;

    public String info(){
        return "学号:" + number + ",年级:" + state + ",成绩:" + score;
    }

    public void say(String name, int age) {
        System.out.println("名字：" + name + "年龄：" + age);
    }
}

class Teacher {
    String name;
    int age;
    int teacherAge;
    String course;

    void say(String name, int age) {
        System.out.println("这个老师是" + name + "年龄是" + age);
    }
}

/*
 * 类中方法的声明和使用
 *
 * 方法：描述类应该具有的功能。
 * 比如：Math类：sqrt()\random() \...
 *     Scanner类：nextXxx() ...
 *     Arrays类：sort() \ binarySearch() \ toString() \ equals() \ ...
 *
 * 1.举例：
 * public void eat(){}
 * public void sleep(int hour){}
 * public String getName(){}
 * public String getNation(String nation){}
 *
 * 2. 方法的声明：权限修饰符  返回值类型  方法名(形参列表){
 * 					方法体
 * 			  }
 *   注意：static、final、abstract 来修饰的方法，后面再讲。
 *
 * 3. 说明：
 * 		3.1 关于权限修饰符：默认方法的权限修饰符先都使用public
 * 			Java规定的4种权限修饰符：private、public、缺省、protected  -->封装性再细说
 *
 * 		3.2 返回值类型： 有返回值  vs 没有返回值
 * 			3.2.1  如果方法有返回值，则必须在方法声明时，指定返回值的类型。同时，方法中，需要使用
 *                return关键字来返回指定类型的变量或常量：“return 数据”。
 * 				  如果方法没有返回值，则方法声明时，使用void来表示。通常，没有返回值的方法中，就不需要
 *               使用return.但是，如果使用的话，只能“return;”表示结束此方法的意思。
 *
 * 			3.2.2 我们定义方法该不该有返回值？
 * 				① 题目要求
 * 				② 凭经验：具体问题具体分析
 *
 *      3.3 方法名：属于标识符，遵循标识符的规则和规范，“见名知意”
 *      3.4 形参列表:方法名可以声明0个、1个，或多个形参。
 *      	3.4.1 格式:数据类型1 形参1，数据类型2 形参2,...
 *
 *      	3.4.2 我们定义方法时，该不该定义形参？
 *      		① 题目要求
 *      		② 凭经验，具体问题具体分析
 *      3.5 方法体:方法功能的体现。
 *  4. return关键字的使用：
 *  	1.使用范围:使用在方法体中
 *  	2.作业:① 结束方法
 *  		  ② 针对于有返回值类型的方法，使用"return 数据"方法返回所要的数据。
 *  	3.注意点:return关键字后不可声明执行语句。
 *  5. 方法的使用中，可以调用当前类的属性或方法。
 *  		特殊的:方法A中又调用了方法A:递归方法。
 *  	方法中不能定义其他方法。
 */
class Customer {
    // 方法的声明：权限修饰符  返回值类型  方法名(形参列表){方法体 }
    String name;
    int age;
    boolean isMale;

    //方法
    public void eat() {
        System.out.println("客户吃饭");
        return;
    }

    public void sleep(int hour) {
        System.out.println("休息了" + hour + "个小时");
        //方法的使用中，可以调用当前类的属性或方法。
        eat();
//        sleep(2);//特殊的:方法A中又调用了方法A:递归方法。
    }

    public String getName() {
        if (age > 18) {
            return name;
        } else {
            return "tom";
        }
    }

    public String getNation(String nation) {
        String info = "我的国籍是" + nation;
        return info;
    }

    //函数内部不能再声明函数
    public void info() {
        //错误的
//		public void swim(){
//		}
    }

}

//利用面向对象的编程方法，设计类Circle计算圆的面积。
class Circle {
    double radius;

    public double findArea() {
        double area = Math.PI * radius * radius;
        return area;
    }


}


